package com.wang.back.controller;

import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.wang.common.pojo.BasePojoEnum;
import com.wang.common.pojo.BaseQuery;
import com.wang.common.util.ConstatFinalUtil;
import com.wang.common.web.controller.BaseController;
import com.wang.sys.pojo.AtSysConfig;
import com.wang.sys.pojo.AtSysConfigQuery;
import com.wang.sys.pojo.AtSysFiles;
import com.wang.sys.pojo.AtSysFilesQuery;
import com.wang.sys.service.AtSysConfigService;
import com.wang.sys.service.AtSysFilesService;
import jakarta.servlet.http.HttpServletRequest;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;

/**
 * 示例的Controller
 * @author ZjxMi
 */
@Controller
@RequestMapping("/back/system")
@Log4j2
public class SystemBackController extends BaseController {
    @Autowired
    private AtSysConfigService configService;
    @Autowired
    private AtSysFilesService sysFilesService;
    @Autowired
    private AtSysConfigService sysConfigService;

    /**
     * 系统配置查询多条
     * @return
     */
    @RequestMapping("/configList")
    public String configList(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置列表==");
        /* 分页对象 */
        IPage<AtSysConfig> paramPage = null;
        try {
            paramPage = new Page<>(paramQuery.getCurrent(), paramQuery.getSize());
        } catch (Exception e) {
            paramPage = new Page<>(1, 20);
        }
        /* 时间处理 */
        if (StringUtils.isNotEmpty(paramQuery.getStDate())) {
            paramQuery.setPubTimeSt(this.dateUtil.strToDateTime(paramQuery.getStDate()));
        }
        if (StringUtils.isNotEmpty(paramQuery.getEdDate())) {
            paramQuery.setPubTimeEd(this.dateUtil.strToDateTime(paramQuery.getEdDate()));
        }
        paramQuery.addLike();
        /* 查询对象 */
        List<AtSysConfig> dataList = this.configService.findList(paramPage, paramQuery);
        paramQuery.removeLike();
        /* 列表数据 */
        model.addAttribute("dataList", dataList);
        /* 分页数据 */
        model.addAttribute("pageInfoUtil", paramPage);
        model.addAttribute("paramQuery", paramQuery);
        model.addAttribute("enumsOne", new AtSysConfig());
        /* 查询数据 */
        return "back/system/configList";
    }

    /**
     * 系统配置打开添加页面
     * @return
     */
    @RequestMapping("/configInsert")
    public String configInsert(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置添加==");
        model.addAttribute("one", new AtSysConfig());
        /* 查询数据 */
        return "back/system/configInsert";
    }

    /**
     * 系统配置添加提交操作
     * @return
     */
    @RequestMapping("/configInsertSubmit")
    @ResponseBody
    public String configInsertSubmit(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置添加==");
        boolean dbFlag = this.configService.save(paramQuery.getEntity());
        JSONObject resultJson = this.proccedResponseJson(dbFlag);
        /* 返回json给客户端 */
        return resultJson.toJSONString();
    }

    /**
     * 系统配置打开更新页面
     * 更新和详情是同一个页面;
     * @return
     */
    @RequestMapping("/configUpdate")
    public String configUpdate(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置更新==");
        /* 根据id查询 */
        AtSysConfig one = this.configService.findOne(paramQuery);
        model.addAttribute("one", one);

        if (BaseQuery.FINAL_OPER_UPDATE.equalsIgnoreCase(paramQuery.getOperType())) {
            /* 查询数据 */
            return "back/system/configUpdate";
        }
        /* 查询数据 */
        return "back/system/configInfo";
    }

    /**
     * 系统配置更新提交操作
     * <pre>
     * 系统配置表有10个字段,用户填写的只有5个字段;
     * 更新的时候只更新5个字段;剩下的5个字段不用更新
     * 千万不要把页面中传的参数SpringMVC会自动创建对象,这个对象不要直接更新数据库,很危险;
     * </pre>
     * @return
     */
    @RequestMapping("/configUpdateSubmit")
    @ResponseBody
    public String configUpdateSubmit(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置更新提交==");
        boolean dbFlag = this.configService.updateById(paramQuery.getEntity());
        JSONObject resultJson = this.proccedResponseJson(dbFlag);
        /* 返回json给客户端 */
        return resultJson.toJSONString();
    }

    /**
     * 系统配置打开添加页面
     * @return
     */
    @RequestMapping("/configBatch")
    public String configBatch(AtSysConfigQuery paramQuery, Model model){
        log.info("==系统配置批量提交==");
        String operType = paramQuery.getOperType();
        String[] ids = paramQuery.getIds();
        String info = "操作成功";
        int totalCount = 0;
        int succedCount = 0;
        int failedCount = 0;
        if (StringUtils.isNotEmpty(operType)) {
            if (Objects.nonNull(ids) && ids.length > 0) {
                totalCount = ids.length;
                for (String idTemp : ids) {
                    try {
                        AtSysConfigQuery paramQueryTemp = new AtSysConfigQuery();
                        AtSysConfig entity = paramQueryTemp.getEntity();
                        entity.setId(idTemp);
                        /* 根据id查询每一个 记录对象 */
                        AtSysConfig dataDbResult = this.configService.findOne(paramQueryTemp);
                        if (dataDbResult != null) {
                            boolean dbFlag = false;
                            if (BasePojoEnum.OPERTYPE_DELETE.getCode().equalsIgnoreCase(operType)) {
                                /* 删除 */
                                dbFlag = this.configService.removeById(idTemp);
                            } else if (BasePojoEnum.OPERTYPE_RESTORE.getCode().equalsIgnoreCase(operType)) {
                                /* 还原,为什么这里面要传这么多参数,一切的一切就是为了在xml中拼装sql语句 */
                                paramQueryTemp = new AtSysConfigQuery();
                                entity = paramQueryTemp.getEntity();
                                entity.setDelFlag(BasePojoEnum.DELFLAG_NO.getCode());
                                entity.setId(idTemp);
                                paramQueryTemp.setOperType(BasePojoEnum.OPERTYPE_RESTORE.getCode());
                                dbFlag = this.configService.updateBatch(paramQueryTemp) > 0 ;
                            } else if (BasePojoEnum.OPERTYPE_EMPTY.getCode().equalsIgnoreCase(operType)) {
                                /* 清空 */
                                paramQueryTemp = new AtSysConfigQuery();
                                entity = paramQueryTemp.getEntity();
                                entity.setId(idTemp);
                                dbFlag = this.configService.deleteBatch(paramQueryTemp) > 0 ;
                            } else if (BasePojoEnum.OPERTYPE_UPDATESTATUS.getCode().equalsIgnoreCase(operType)) {
                                /* 批量修改状态 */
                                dataDbResult.setStatus(paramQuery.getEntity().getStatus());
                                dbFlag = this.configService.updateById(dataDbResult);
                            }
                            if (dbFlag) {
                                succedCount ++;
                            } else {
                                failedCount ++;
                            }
                        }
                    } catch (Exception e) {
                        log.error("批量操作失败了,id:{}", idTemp, e);
                        failedCount ++;
                    }
                }
            } else {
                /* 未选择类型,ids */
                info = "ids为空";
            }
        } else {
            /* 操作类型未选择 */
            info = "操作类型未选择";
        }

        log.info("==批量操作日志:提示信息:{}, 总条数:{},成功条数:{},失败条数:{}==", info, totalCount, succedCount, failedCount);
        /* 查询数据 */
        return "redirect:/back/system/configList";
    }

    @RequestMapping("/reloadCache")
    @ResponseBody
    public String reloadCache(Model model){
        log.info("==重新加载配置到缓存中==");
        long dbRes = this.configService.reloadCache();
        Map<String,String> paramsPap = new HashMap<>(1);
        paramsPap.put("message", ";加载条数:" + dbRes);
        JSONObject resultJson = this.proccedResponseJson(dbRes > 0, paramsPap);
        /* 返回json给客户端 */
        return resultJson.toJSONString();
    }

    /**
     * 系统_文件查询多条
     * @return
     */
    @RequestMapping("/filesList")
    public String filesList(AtSysFilesQuery paramQuery, Model model){
        log.info("==系统_文件列表==");
        /* 分页对象 */
        IPage<AtSysFiles> paramPage = null;
        try {
            paramPage = new Page<>(paramQuery.getCurrent(), paramQuery.getSize());
        } catch (Exception e) {
            paramPage = new Page<>(1, 20);
        }
        /* 时间处理 */
        if (StringUtils.isNotEmpty(paramQuery.getStDate())) {
            paramQuery.setPubTimeSt(this.dateUtil.strToDateTime(paramQuery.getStDate()));
        }
        if (StringUtils.isNotEmpty(paramQuery.getEdDate())) {
            paramQuery.setPubTimeEd(this.dateUtil.strToDateTime(paramQuery.getEdDate()));
        }
        paramQuery.addLike();
        /* 查询对象 */
        List<AtSysFiles> dataList = this.sysFilesService.findList(paramPage, paramQuery);
        paramQuery.removeLike();
        /* 列表数据 */
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_DATALIST, dataList);
        /* 分页数据 */
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_PAGEINFOUTIL, paramPage);
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_PARAMQUERY, paramQuery);
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_ENUMSONE, new AtSysFiles());
        /* 查询数据 */
        return "back/system/filesList";
    }

    /**
     * 系统_文件打开添加页面
     * @return
     */
    @RequestMapping("/filesInsert")
    public String filesInsert(AtSysFilesQuery paramQuery, Model model){
        log.info("==系统_文件添加==");
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_ONE, new AtSysFiles());
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_PARAMQUERY, paramQuery);
        /* 查询数据 */
        return "back/system/filesInsert";
    }

    /**
     * 系统_文件添加提交操作
     * @return
     */
    @RequestMapping("/filesInsertSubmit")
    @ResponseBody
    public String filesInsertSubmit(AtSysFilesQuery paramQuery,MultipartFile file, Model model){
        log.info("==系统_文件添加==");
        boolean dbFlag = false;
        try {
            if (Objects.nonNull(file)) {
                AtSysFiles entity = paramQuery.getEntity();
                String originalFilename = file.getOriginalFilename();
                String extendName = originalFilename.substring(originalFilename.lastIndexOf("."), originalFilename.length());

                /* 真实路径  */
                AtSysConfig truePathConfig = this.sysConfigService.getById(ConstatFinalUtil.FINAL_CONFIG_TRUEPATH);
                String truePath = truePathConfig.getValStr();

                /* 相对路径  */
                AtSysConfig trueRelaPathConfig = this.sysConfigService.getById(ConstatFinalUtil.FINAL_CONFIG_RELAPATH);
                String relaPath = trueRelaPathConfig.getValStr();

                /* /uploadfile/goods/brand/2023-12-20/uuid.jpg */
                relaPath = relaPath + "/system/files/" + this.dateUtil.dateToStr(new Date()) + "/" + UUID.randomUUID().toString() + extendName;
                /* 拷贝文件 */
                File trueFile = new File(truePath, relaPath);
                if (!trueFile.getParentFile().exists()) {
                    /* 创建父文件夹 */
                    trueFile.getParentFile().mkdirs();
                }
                /* 保存文件 */
                file.transferTo(trueFile);
                entity.setPath(relaPath);
                /* 原始文件名 */
                entity.setName(originalFilename);
                /* 处理后的名称 */
                entity.setFileName(trueFile.getName());
                entity.setLength(Integer.parseInt(file.getSize() + ""));

                dbFlag = this.sysFilesService.save(entity);
            }
        } catch (IOException e) {
            log.error("上传文件失败;", e );
        }
        JSONObject resultJson = this.proccedResponseJson(dbFlag);
        /* 返回json给客户端 */
        return resultJson.toJSONString();
    }

    /**
     * 系统_文件打开更新页面
     * 更新和详情是同一个页面;
     * @return
     */
    @RequestMapping("/filesUpdate")
    public String filesUpdate(AtSysFilesQuery paramQuery, Model model, HttpServletRequest request){
        log.info("==系统_文件更新==");
        /* 根据id查询 */
        AtSysFiles one = this.sysFilesService.findOne(paramQuery);
        model.addAttribute(ConstatFinalUtil.FINAL_CODE_ONE, one);
        if (StringUtils.isNotEmpty(one.getPath())) {
            one.setPath(request.getContextPath() + one.getPath());
        }

        if (BaseQuery.FINAL_OPER_UPDATE.equalsIgnoreCase(paramQuery.getOperType())) {
            /* 查询数据 */
            return "back/system/filesUpdate";
        }
        /* 查询数据 */
        return "back/system/filesInfo";
    }

    /**
     * 朝代更新提交操作
     * <pre>
     * 朝代表有10个字段,用户填写的只有5个字段;
     * 更新的时候只更新5个字段;剩下的5个字段不用更新
     * 千万不要把页面中传的参数SpringMVC会自动创建对象,这个对象不要直接更新数据库,很危险;
     * </pre>
     * @return
     */
    @RequestMapping("/filesUpdateSubmit")
    @ResponseBody
    public String filesUpdateSubmit(AtSysFilesQuery paramQuery, Model model){
        log.info("==朝代更新提交==");
        AtSysFiles entity = paramQuery.getEntity();
        if (StringUtils.isNotEmpty(paramQuery.getPubTime())) {
            entity.setPubTime(this.dateUtil.strToDateTime(paramQuery.getPubTime()));
        }
        boolean dbFlag = this.sysFilesService.updateById(entity);
        JSONObject resultJson = this.proccedResponseJson(dbFlag);
        /* 返回json给客户端 */
        return resultJson.toJSONString();
    }

    /**
     * 朝代打开添加页面
     * @return
     */
    @RequestMapping("/filesBatch")
    @ResponseBody
    public String filesBatch(AtSysFilesQuery paramQuery, Model model){
        log.info("==朝代批量提交==");
        String operType = paramQuery.getOperType();
        String[] ids = paramQuery.getIds();
        String info = ConstatFinalUtil.FINAL_OPER_SUCCESS;
        int totalCount = 0;
        int succedCount = 0;
        int failedCount = 0;
        if (StringUtils.isNotEmpty(operType)) {
            if (Objects.nonNull(ids) && ids.length > 0) {
                totalCount = ids.length;
                for (String idTemp : ids) {
                    try {
                        AtSysFilesQuery paramQueryTemp = new AtSysFilesQuery();
                        AtSysFiles entity = paramQueryTemp.getEntity();
                        entity.setId(idTemp);
                        /* 根据id查询每一个 记录对象 */
                        AtSysFiles dataDbResult = this.sysFilesService.findOne(paramQueryTemp);
                        if (dataDbResult != null) {
                            boolean dbFlag = false;
                            if (BasePojoEnum.OPERTYPE_DELETE.getCode().equalsIgnoreCase(operType)) {
                                /* 删除 */
                                dbFlag = this.sysFilesService.removeById(idTemp);
                            } else if (BasePojoEnum.OPERTYPE_RESTORE.getCode().equalsIgnoreCase(operType)) {
                                /* 还原,为什么这里面要传这么多参数,一切的一切就是为了在xml中拼装sql语句 */
                                paramQueryTemp = new AtSysFilesQuery();
                                entity = paramQueryTemp.getEntity();
                                entity.setDelFlag(BasePojoEnum.DELFLAG_NO.getCode());
                                entity.setId(idTemp);
                                paramQueryTemp.setOperType(BasePojoEnum.OPERTYPE_RESTORE.getCode());
                                dbFlag = this.sysFilesService.updateBatch(paramQueryTemp) > 0 ;
                            } else if (BasePojoEnum.OPERTYPE_EMPTY.getCode().equalsIgnoreCase(operType)) {
                                /* 清空 */
                                paramQueryTemp = new AtSysFilesQuery();
                                entity = paramQueryTemp.getEntity();
                                entity.setId(idTemp);
                                dbFlag = this.sysFilesService.deleteBatch(paramQueryTemp) > 0 ;
                            } else if (BasePojoEnum.OPERTYPE_UPDATESTATUS.getCode().equalsIgnoreCase(operType)) {
                                /* 批量修改状态 */
                                dataDbResult.setStatus(paramQuery.getEntity().getStatus());
                                dbFlag = this.sysFilesService.updateById(dataDbResult);
                            }
                            if (dbFlag) {
                                succedCount ++;
                            } else {
                                failedCount ++;
                            }
                        }
                    } catch (Exception e) {
                        log.error("批量操作失败了,id:{}", idTemp, e);
                        failedCount ++;
                    }
                }
            } else {
                /* 未选择类型,ids */
                info = "ids为空";
            }
        } else {
            /* 操作类型未选择 */
            info = "操作类型未选择";
        }

        String messInfo = "批量操作日志:提示信息:${info}, 总条数:${totalCount},成功条数:${succedCount},失败条数:${failedCount}";
        Map<String,String> paramsMap = new HashMap<>(1);
        paramsMap.put("info", info);
        paramsMap.put("totalCount", String.valueOf(totalCount));
        paramsMap.put("succedCount", String.valueOf(succedCount));
        paramsMap.put("failedCount", String.valueOf(failedCount));
        messInfo = this.regexUtil.replaceOperator(messInfo, paramsMap);

        paramsMap = new HashMap<>(1);
        paramsMap.put(ConstatFinalUtil.FINAL_CONFIG_INFO_SUCCESS_PARAM1, messInfo);
        /* 查询数据 */
        JSONObject resultJson = this.proccedResponseJson(ConstatFinalUtil.FINAL_OPER_SUCCESS.equalsIgnoreCase(info), paramsMap);
        log.info("==结果:{}==", resultJson);
        return resultJson.toJSONString();
    }
}
